﻿#include"C++.h"

//int main()
//{   
//    cout << "Hello World" << endl;   //endl - 换行
//    //system("pause");
//    return 0;
//}


//int main()
//{
//	const int a = 0;     //const - 修饰变量为常量
//	cout << a << endl;
//	//system("pause");   //pause - 暂停
//	return 0;
//}


//int main()
//{
//	cout <<"short占用内存空间大小：" << sizeof(short) << endl;
//	cout << "int占用内存空间大小：" << sizeof(int) << endl;
//	cout << "long占用内存空间大小：" << sizeof(long) << endl;
//	cout << "long long占用内存空间大小：" << sizeof(long long) <<endl;
//	cout << "float占用内存空间大小：" << sizeof(float) << endl;
//	cout << "double占用内存空间大小：" << sizeof(double) << endl;
//	return 0;
//}


//int main()
//{
//	char arr2[] = "Hello world";//C语言风格字符串
//	string arr1 = "Hello world";//C++风格字符串
//	cout << arr1 << endl;
//	return 0;
//}


//int main()
//{//布尔型 - 只有true和false - 本质为1和0
//	bool a = true;
//	bool b = false;
//	cout << a << endl;
//	cout << b << endl;
//	cout << "布尔型所占用的内存空间大小：" << sizeof(bool) << endl;
//	return 0;
//}


//int main()
//{
//	int a = 0;
//	cout << "a=";
//	cin >> a;
//	cout << a << endl;
//	return 0;
//}


//namespace - namespace本质是定义出⼀个域，这个域跟全局域各⾃独⽴，不同的域可以定义同名变量
//项⽬⼯程中多⽂件中定义的同名namespace会认为是⼀个namespace，不会冲突
//C++标准库都放在⼀个叫std(standard)的命名空间中
//namespace abc
//{
//	int rand = 10;
//}
//int a = 0;
//int main()
//{
//	printf("%p\n", rand);
//	printf("%d\n", rand);
//	int a = 1;
//	printf("%d\n", a);
//	// :: - 域作用限定符
//	printf("%d\n", ::a);
//	printf("%d\n", abc::rand);
//	return 0;
//}

//namespace bit
//{
//	// 命名空间中可以定义变量/函数/类型
//	int rand = 10;
//	int Add(int left, int right)
//	{
//		return left + right;
//	}
//	struct Node
//	{
//		struct Node* next;
//		int val;
//	};
//}
//int main()
//{
//	// 这⾥默认是访问的是全局的rand函数指针
//	printf("%p\n", rand);
//	// 这⾥指定bit命名空间中的rand
//	printf("%d\n", bit::rand);
//	printf("%d\n", bit::Add(1, 1));
//	struct bit::Node p1;
//	return 0;
//}

//namespace bit
//{
//	namespace aa
//	{
//		int rand = 1;
//		int Add(int left, int right)
//		{
//			return left + right;
//		}
//	}
//
//	namespace bb
//	{
//		int rand = 2;
//		int Add(int left, int right)
//		{
//			return (left + right) * 10;
//		}
//	}
//}
//int main()
//{
//	printf("%d\n", bit::aa::rand);
//	printf("%d\n", bit::bb::rand);
//	printf("%d\n", bit::aa::Add(1, 2));
//	printf("%d\n", bit::bb::Add(1, 2));
//	return 0;
//}


//int main()
//{
//	int i = 1234;
//	int j = -123;
//	//std::cout << i << endl;
//	cout << i << endl;
//	// << - 流插入运算符
//	// >> - 流提取运算符
//	
//	return 0;
//}


//int main()
//{
//	int a = 0;
//	double b = 0.1111111111;//C++默认保留5位小数
//	char c = 'x';
//
//	cout << a << " " << b << " " << c << endl;
//	std::cout << a << " " << b << " " << c << std::endl;
//
//	// 可以自动识别变量的类型
//	cin >> a;
//	cin >> b >> c;
//
//	cout << a << " " << b << " " << c << endl;
//	std::cout << a << " " << b << " " << c << std::endl;
//	return 0;
//}


//int main()
//{
//	// 在io需求⽐较⾼的地⽅，如部分⼤量输⼊的竞赛题中，加上以下3⾏代码
//	// 可以提⾼C++IO效率
//	ios_base::sync_with_stdio(false);
//	cin.tie(nullptr);
//	cout.tie(nullptr);
//	return 0;
//}


//void Func(int a = 0)
//{
//	cout << a << endl;
//}
//// 全缺省 - 是全部形参给缺省值
//void Func1(int a = 10, int b = 20, int c = 30)
//{
//	cout << "a = " << a << endl;
//	cout << "b = " << b << endl;
//	cout << "c = " << c << endl << endl;
//}
//// 半缺省 - 部分形参给缺省值 - 规定半缺省参数必须从右往左依次连续缺省，不能间隔跳跃给缺省值
//void Func2(int a, int b = 10, int c = 20)
//{
//	cout << "a = " << a << endl;
//	cout << "b = " << b << endl;
//	cout << "c = " << c << endl << endl;
//}
//int main()
//{
//	//缺省参数（默认参数） - 声明或定义函数时为函数的参数指定⼀个缺省值。在调⽤该函数时，如果没有指定实参
//	//                       则采⽤该形参的缺省值，否则使⽤指定的实参，缺省参数分为全缺省和半缺省参数。
//
//	//函数声明和定义分离时，缺省参数不能在函数声明和定义中同时出现，规定必须函数声明给缺省值。
//
//	Func(); // 没有传参时，使⽤参数的默认值
//	Func(10); // 传参时，使⽤指定的实参
//
//	//带缺省参数的函数调⽤，C++规定必须从左到右依次给实参，不能跳跃给实参
//	Func1();
//	Func1(1);
//	Func1(1, 2);
//	Func1(1, 2, 3);
//
//	Func2(100);
//	Func2(100, 200);
//	Func2(100, 200, 300);
//	return 0;
//}


//函数重载 - C++⽀持在同⼀作⽤域中出现同名函数，但是要求这些同名函数的形参不同，可以是参数个数不同或者类型不同
// 1、参数类型不同
//int Add(int left, int right)
//{
//	cout << "int Add(int left, int right)" << endl;
//	return left + right;
//}
//double Add(double left, double right)
//{
//	cout << "double Add(double left, double right)" << endl;
//	return left + right;
//}
//// 2、参数个数不同
//void f()
//{
//	cout << "f()" << endl;
//}
//void f(int a)
//{
//	cout << "f(int a)" << endl;
//}
//// 3、参数类型顺序不同
//void f(int a, char b)
//{
//	cout << "f(int a,char b)" << endl;
//}
//void f(char b, int a)
//{
//	cout << "f(char b, int a)" << endl;
//}
//// 返回值不同不能作为重载条件，因为调⽤时也⽆法区分
////void fxx()
////{}
////
////int fxx()
////{
//// return 0;
////}
//// 下⾯两个函数构成重载
//// f()但是调⽤时，会报错，存在歧义，编译器不知道调⽤谁
//void f1()
//{
//	cout << "f()" << endl;
//}
//void f1(int a = 10)
//{
//	cout << "f(int a)" << endl;
//}
//int main()
//{
//	Add(10, 20);
//	Add(10.1, 20.2);
//	f();
//	f(10);
//	f(10, 'a');
//	f('a', 10);
//	return 0;
//}


// 引用 - 引⽤不是新定义⼀个变量，⽽是给已存在变量取了⼀个别名，编译器不会为引⽤变量开辟内存空间，它和它引⽤的变量共⽤同⼀块内存空间。
		//类型& 引⽤别名 = 引⽤对象;
// 特性 - 引⽤在定义时必须初始化 - ⼀个变量可以有多个引⽤ - 引⽤⼀旦引⽤⼀个实体，再不能引⽤其他实体
// 使用 - 引⽤在实践中主要是于引⽤传参和引⽤做返回值中减少拷⻉提⾼效率和改变引⽤对象时同时改变被引⽤对象。
//int main()
//{
//	int a = 0;
//	// 引⽤：b和c是a的别名
//	int& b = a;
//	int& c = a;
//	// 也可以给别名b取别名，d相当于还是a的别名
//	int& d = b;
//	++d;
//	// 这⾥取地址看到是⼀样的
//	cout << &a << endl;
//	cout << &b << endl;
//	cout << &c << endl;
//	cout << &d << endl;
//	return 0;
//}


// const引用 - 可以引⽤⼀个const对象，但是必须⽤const引⽤。const引⽤也可以引⽤普通对象，因为对象的访问权限在引⽤过程中可以缩⼩，但是不能放⼤
//int main()
//{
//	const int a = 10;
//	// 编译报错：error C2440: “初始化”: ⽆法从“const int”转换为“int &”
//	// 这⾥的引⽤是对a访问权限的放⼤
//	//int& ra = a;
//
//	const int& ra = a;
//	// 编译报错：error C3892: “ra”: 不能给常量赋值
//	//ra++;
//
//	// 这⾥的引⽤是对b访问权限的缩⼩
//	int b = 20;
//	const int& rb = b;
//	// 编译报错：error C3892: “rb”: 不能给常量赋值
//	//rb++;
// 
//	const int& rc = 30;
//
////在类型转换中会产⽣临时对象存储中间值，也就是，rb和rd引⽤的都是临时对象，⽽C++规定临时对象具有常性,所以这⾥就触发了权限放⼤，必须要⽤常引⽤才可以
//	//int& rd = (a + b);
//
//	return 0;
//}

//int main()
//{
//	int a = 10;
//
//	const int& ra = 30;
//
//	// 编译报错: “初始化”: ⽆法从“int”转换为“int &”
//	// int& rb = a * 3;
//	const int& rb = a * 3;
//
//	double d = 12.34;
//	// 编译报错：“初始化”: ⽆法从“double”转换为“int &”
//	// int& rd = d;
//	const int& rd = d;
//
//	return 0;
//}

//语法概念上引⽤是⼀个变量的取别名不开空间，指针是存储⼀个变量地址，要开空间。
//引⽤在定义时必须初始化，指针建议初始化，但是语法上不是必须的。
//引⽤在初始化时引⽤⼀个对象后，就不能再引⽤其他对象；⽽指针可以在不断地改变指向对象。
//引⽤可以直接访问指向对象，指针需要解引⽤才是访问指向对象。
//sizeof中含义不同，引⽤结果为引⽤类型的⼤⼩，但指针始终是地址空间所占字节个数(32位平台下占4个字节，64位下是8byte)
//指针很容易出现空指针和野指针的问题，引⽤很少出现，引⽤使⽤起来相对更安全⼀些。


// inline - ⽤inline修饰的函数叫做内联函数，编译时C++编译器会在调⽤的地⽅展开内联函数，这样调⽤内联函数就需要建⽴栈帧了，就可以提⾼效率
//vs编译器 debug版本下⾯默认是不展开inline的，这样⽅便调试，debug版本想展开需要设置
//inline对于编译器⽽⾔只是⼀个建议，加了inline编译器也可以选择在调⽤的地⽅不展开，不同编译器关于inline什么情况展开各不相同，因为C++标准没有规定这个
//inline适⽤于频繁调⽤的短⼩函数，对于递归函数，代码相对多⼀些的函数，加上inline也会被编译器忽略
//inline不建议声明和定义分离到两个⽂件，分离会导致链接错误。因为inline被展开，就没有函数地址，链接时会出现报错
//inline int Add(int x, int y)
//{
//	int ret = x + y;
//	ret += 1;
//	ret += 1;
//	ret += 1;
//	return ret;
//}
//int main()
//{
//	// 可以通过汇编观察程序是否展开
//	// 有call Add语句就是没有展开，没有就是展开了
//	int ret = Add(1, 2);
//	cout << Add(1, 2) * 5 << endl;
//	return 0;
//}


//nullptr - 空指针 - C++11中引⼊nullptr，nullptr是⼀个特殊的关键字，nullptr是⼀种特殊类型的字⾯量，它可以转换成任意其他类型的指针类型
//使⽤nullptr定义空指针可以避免类型转换的问题，因为nullptr只能被隐式地转换为指针类型，⽽不能被转换为整数类型
//void f(int x)
//{
//	cout << "f(int x)" << endl;
//}
//void f(int* ptr)
//{
//	cout << "f(int* ptr)" << endl;
//}
//int main()
//{
//	f(0);
//	// 本想通过f(NULL)调⽤指针版本的f(int*)函数，但是由于NULL被定义成0，调⽤了f(intx)，因此与程序的初衷相悖。
//	f(NULL);
//	f((int*)NULL);
//
//	// 编译报错：error C2665: “f”: 2 个重载中没有⼀个可以转换所有参数类型
//	// f((void*)NULL);
//
//	 f(nullptr);
//
//	return 0;
//}
